< Summary

Class:GDX.Tables.StableTable
Assembly:GDX
File(s):D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/Tables/StableTable.cs
Covered lines:0
Uncovered lines:1204
Coverable lines:1204
Total lines:1828
Line coverage:0% (0 of 1204)
Covered branches:0
Total branches:0
Covered methods:0
Total methods:169
Method coverage:0% (0 of 169)

Coverage History

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
StableTable()0%2100%
StableTable()0%2100%
GetDataVersion()0%2100%
GetColumnCount()0%2100%
GetRowCount()0%2100%
GetDisplayName()0%2100%
SetDisplayName(...)0%2100%
GetFlag(...)0%2100%
SetFlag(...)0%2100%
GetAllRowDescriptions()0%20400%
GetRowDescription(...)0%12300%
GetRowDescription(...)0%2100%
SetAllRowDescriptionsOrder(...)0%2100%
GetColumnDescription(...)0%30500%
GetColumnDescription(...)0%2100%
SetAllColumnDescriptionsOrder(...)0%2100%
GetAllColumnDescriptions()0%12300%
AssertColumnIDValid(...)0%20400%
AssertRowIDValid(...)0%30500%
SetColumnName(...)0%2100%
GetColumnName(...)0%2100%
SetRowName(...)0%2100%
GetRowName(...)0%2100%
GetRowNameRef(...)0%2100%
GetColumnNameRef(...)0%2100%
AddRow(...)0%2401500%
AddRows(...)0%4202000%
AddRows(...)0%4202000%
RemoveRow(...)0%6200%
AddColumn(...)0%9923100%
RemoveColumn(...)0%9303000%
SetString(...)0%2100%
SetBool(...)0%2100%
SetChar(...)0%2100%
SetSByte(...)0%2100%
SetByte(...)0%2100%
SetShort(...)0%2100%
SetUShort(...)0%2100%
SetInt(...)0%2100%
SetUInt(...)0%2100%
SetLong(...)0%2100%
SetULong(...)0%2100%
SetFloat(...)0%2100%
SetDouble(...)0%2100%
SetVector2(...)0%2100%
SetVector3(...)0%2100%
SetVector4(...)0%2100%
SetVector2Int(...)0%2100%
SetVector3Int(...)0%2100%
SetQuaternion(...)0%2100%
SetRect(...)0%2100%
SetRectInt(...)0%2100%
SetColor(...)0%2100%
SetLayerMask(...)0%2100%
SetBounds(...)0%2100%
SetBoundsInt(...)0%2100%
SetHash128(...)0%2100%
SetGradient(...)0%2100%
SetAnimationCurve(...)0%2100%
SetObject(...)0%2100%
SetTypeNameForObjectColumn[T](...)0%2100%
GetString(...)0%2100%
GetBool(...)0%2100%
GetChar(...)0%2100%
GetSByte(...)0%2100%
GetByte(...)0%2100%
GetShort(...)0%2100%
GetUShort(...)0%2100%
GetInt(...)0%2100%
GetUInt(...)0%2100%
GetLong(...)0%2100%
GetULong(...)0%2100%
GetFloat(...)0%2100%
GetDouble(...)0%2100%
GetVector2(...)0%2100%
GetVector3(...)0%2100%
GetVector4(...)0%2100%
GetVector2Int(...)0%2100%
GetVector3Int(...)0%2100%
GetQuaternion(...)0%2100%
GetRect(...)0%2100%
GetRectInt(...)0%2100%
GetColor(...)0%2100%
GetLayerMask(...)0%2100%
GetBounds(...)0%2100%
GetBoundsInt(...)0%2100%
GetHash128(...)0%2100%
GetGradient(...)0%2100%
GetAnimationCurve(...)0%2100%
GetObject(...)0%2100%
GetStringRef(...)0%2100%
GetBoolRef(...)0%2100%
GetCharRef(...)0%2100%
GetSbyteRef(...)0%2100%
GetByteRef(...)0%2100%
GetShortRef(...)0%2100%
GetUshortRef(...)0%2100%
GetIntRef(...)0%2100%
GetUintRef(...)0%2100%
GetLongRef(...)0%2100%
GetUlongRef(...)0%2100%
GetFloatRef(...)0%2100%
GetDoubleRef(...)0%2100%
GetVector2Ref(...)0%2100%
GetVector3Ref(...)0%2100%
GetVector4Ref(...)0%2100%
GetVector2IntRef(...)0%2100%
GetVector3IntRef(...)0%2100%
GetQuaternionRef(...)0%2100%
GetRectRef(...)0%2100%
GetRectIntRef(...)0%2100%
GetColorRef(...)0%2100%
GetLayerMaskRef(...)0%2100%
GetBoundsRef(...)0%2100%
GetBoundsIntRef(...)0%2100%
GetHash128Ref(...)0%2100%
GetGradientRef(...)0%2100%
GetAnimationCurveRef(...)0%2100%
GetObjectRef(...)0%2100%
GetStringColumn(...)0%2100%
GetBoolColumn(...)0%2100%
GetCharColumn(...)0%2100%
GetSbyteColumn(...)0%2100%
GetByteColumn(...)0%2100%
GetShortColumn(...)0%2100%
GetUshortColumn(...)0%2100%
GetIntColumn(...)0%2100%
GetUintColumn(...)0%2100%
GetLongColumn(...)0%2100%
GetUlongColumn(...)0%2100%
GetFloatColumn(...)0%2100%
GetDoubleColumn(...)0%2100%
GetVector2Column(...)0%2100%
GetVector3Column(...)0%2100%
GetVector4Column(...)0%2100%
GetVector2IntColumn(...)0%2100%
GetVector3IntColumn(...)0%2100%
GetQuaternionColumn(...)0%2100%
GetRectColumn(...)0%2100%
GetRectIntColumn(...)0%2100%
GetColorColumn(...)0%2100%
GetLayerMaskColumn(...)0%2100%
GetBoundsColumn(...)0%2100%
GetBoundsIntColumn(...)0%2100%
GetHash128Column(...)0%2100%
GetGradientColumn(...)0%2100%
GetAnimationCurveColumn(...)0%2100%
GetObjectColumn(...)0%2100%
SetColumnOrder(...)0%20400%
SetAllColumnOrders(...)0%6200%
SetRowOrder(...)0%20400%
SetAllRowOrders(...)0%6200%
ReSortRows[T](...)0%30500%
AddTypeNameEntryForUnityObjectColumn()0%12300%
RemoveTypeNameEntryForUnityObjectColumn(...)0%12300%
AssertObjectColumnIDValid(...)0%6200%
AddColumnInternal[T](...)0%4622100%
RemoveColumnInternal[T](...)0%12300%
InsertRowsOfTypeInternal[T](...)0%42600%
DeleteRowsOfTypeInternal[T](...)0%30500%
GetCellRef[T](...)0%2100%
GetCell[T](...)0%2100%
SetCell[T](...)0%2100%
GetColumn[T](...)0%2100%
SetRowOrderForColumns[T](...)0%56700%
AssertSortedColumnsArgValid(...)0%20400%
AssertColumnSortOrderValid(...)0%12300%
AssertRowSortOrderValid(...)0%12300%
AssertSorteRowsArgValid(...)0%20400%

File(s)

D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/Tables/StableTable.cs

#LineLine coverage
 1// Copyright (c) 2020-2023 dotBunny Inc.
 2// dotBunny licenses this file to you under the BSL-1.0 license.
 3// See the LICENSE file in the project root for more information.
 4
 5using System;
 6using GDX.Collections;
 7using UnityEngine;
 8
 9namespace GDX.Tables
 10{
 11
 12    [CreateAssetMenu(menuName = "GDX/Stable Table", fileName = "GDXStableTable")]
 13    [Serializable]
 14    public class StableTable : ScriptableObject, ITable
 15    {
 16        [Serializable]
 17        internal struct ColumnEntry
 18        {
 19            public Serializable.SerializableTypes ColumnType;
 20            public int columnDenseIndex;
 21        }
 22
 023        [SerializeField] internal string m_DisplayName = "GDXStableTable";
 24
 25        [SerializeField] internal ArrayHolder<string>[] allStringColumns;
 26        [SerializeField] internal ArrayHolder<bool>[] allBoolColumns;
 27        [SerializeField] internal ArrayHolder<char>[] allCharColumns;
 28        [SerializeField] internal ArrayHolder<sbyte>[] allSbyteColumns;
 29        [SerializeField] internal ArrayHolder<byte>[] allByteColumns;
 30        [SerializeField] internal ArrayHolder<short>[] allShortColumns;
 31        [SerializeField] internal ArrayHolder<ushort>[] allUshortColumns;
 32        [SerializeField] internal ArrayHolder<int>[] allIntColumns;
 33        [SerializeField] internal ArrayHolder<uint>[] allUintColumns;
 34        [SerializeField] internal ArrayHolder<long>[] allLongColumns;
 35        [SerializeField] internal ArrayHolder<ulong>[] allUlongColumns;
 36        [SerializeField] internal ArrayHolder<float>[] allFloatColumns;
 37        [SerializeField] internal ArrayHolder<double>[] allDoubleColumns;
 38        [SerializeField] internal ArrayHolder<Vector2>[] allVector2Columns;
 39        [SerializeField] internal ArrayHolder<Vector3>[] allVector3Columns;
 40        [SerializeField] internal ArrayHolder<Vector4>[] allVector4Columns;
 41        [SerializeField] internal ArrayHolder<Vector2Int>[] allVector2IntColumns;
 42        [SerializeField] internal ArrayHolder<Vector3Int>[] allVector3IntColumns;
 43        [SerializeField] internal ArrayHolder<Quaternion>[] allQuaternionColumns;
 44        [SerializeField] internal ArrayHolder<Rect>[] allRectColumns;
 45        [SerializeField] internal ArrayHolder<RectInt>[] allRectIntColumns;
 46        [SerializeField] internal ArrayHolder<Color>[] allColorColumns;
 47        [SerializeField] internal ArrayHolder<LayerMask>[] allLayerMaskColumns;
 48        [SerializeField] internal ArrayHolder<Bounds>[] allBoundsColumns;
 49        [SerializeField] internal ArrayHolder<BoundsInt>[] allBoundsIntColumns;
 50        [SerializeField] internal ArrayHolder<Hash128>[] allHash128Columns;
 51        [SerializeField] internal ArrayHolder<Gradient>[] allGradientColumns;
 52        [SerializeField] internal ArrayHolder<AnimationCurve>[] allAnimationCurveColumns;
 53        [SerializeField] internal ArrayHolder<UnityEngine.Object>[] allObjectRefColumns;
 54        [SerializeField] internal string[] allObjectRefTypenames;
 055        [SerializeField] internal ArrayHolder<string>[] allColumnNames = new ArrayHolder<string>[Serializable.Serializab
 56
 57        [SerializeField] internal int[] rowIDToDenseIndexMap;
 58        [SerializeField] internal int[] rowDenseIndexToIDMap;
 59        [SerializeField] internal string[] rowNames;
 60        [SerializeField] internal int rowEntriesFreeListHead;
 61
 62        [SerializeField]
 63        internal int rowCount;
 64
 65        [SerializeField] internal ColumnEntry[] columnIDToDenseIndexMap;
 66        [SerializeField] internal int[] columnIDToSortOrderMap;
 67        [SerializeField] internal int[] sortedOrderToColumnIDMap;
 68
 69        // TODO move with other block
 070        [SerializeField] ArrayHolder<int>[] columnDenseIndexToIDMap = new ArrayHolder<int>[Serializable.SerializableType
 71
 72        [SerializeField]
 73        internal int columnEntriesFreeListHead;
 74
 75        [SerializeField]
 76        internal int combinedColumnCount;
 77
 78        [SerializeField]
 079        internal ulong dataVersion = 1;
 80
 81        [SerializeField] BitArray8 m_Flags;
 82
 083        internal static string s_UnityObjectString = typeof(UnityEngine.Object).AssemblyQualifiedName;
 84
 85        public ulong GetDataVersion()
 086        {
 087            return dataVersion;
 088        }
 89
 90        /// <inheritdoc />
 91        public int GetColumnCount()
 092        {
 093            return combinedColumnCount;
 094        }
 95
 96        /// <inheritdoc />
 97        public int GetRowCount()
 098        {
 099            return rowCount;
 0100        }
 101
 102        public string GetDisplayName()
 0103        {
 0104            return m_DisplayName;
 0105        }
 106
 107        public void SetDisplayName(string displayName)
 0108        {
 0109            m_DisplayName = displayName;
 0110        }
 111
 112        public bool GetFlag(ITable.Flags flag)
 0113        {
 0114            return m_Flags[(byte)flag];
 0115        }
 116
 117        public void SetFlag(ITable.Flags flag, bool toggle)
 0118        {
 0119            m_Flags[(byte)flag] = toggle;
 0120        }
 121
 122        public ITable.RowDescription[] GetAllRowDescriptions()
 0123        {
 0124            if (combinedColumnCount == 0 || rowCount == 0) return null;
 0125            ITable.RowDescription[] returnArray = new ITable.RowDescription[rowCount];
 0126            string empty = string.Empty;
 0127            for (int i = 0; i < rowCount; i++)
 0128            {
 0129                returnArray[i].InternalIndex = rowDenseIndexToIDMap[i];
 0130                returnArray[i].Name = rowNames[i];
 0131            }
 132
 0133            return returnArray;
 0134        }
 135        public ITable.RowDescription GetRowDescription(string name)
 0136        {
 0137            for (int i = 0; i < rowCount; i++)
 0138            {
 0139                string nameAt = rowNames[i];
 140
 0141                if (nameAt == name)
 0142                {
 0143                    return new ITable.RowDescription
 144                    {
 145                        InternalIndex = rowDenseIndexToIDMap[i],
 146                        Name = nameAt,
 147                    };
 148                }
 0149            }
 150
 0151            throw new ArgumentException("Row with name " + name + " does not exist in the table");
 0152        }
 153
 154        public ITable.RowDescription GetRowDescription(int order)
 0155        {
 0156            return new ITable.RowDescription
 157            {
 158                InternalIndex = rowDenseIndexToIDMap[order],
 159                Name = rowNames[order],
 160            };
 0161        }
 162
 163        public void SetAllRowDescriptionsOrder(ITable.RowDescription[] orderedRows)
 0164        {
 165            // TODO: @adam array coming in be in the new order, just use the internalIndex (stable to reorder inside her
 0166            throw new NotImplementedException();
 167        }
 168
 169        public ITable.ColumnDescription GetColumnDescription(string name)
 0170        {
 0171            for (int i = 0; i < Serializable.SerializableTypesCount; i++)
 0172            {
 0173                string[] columnNames = allColumnNames[i].TArray;
 174
 0175                if (columnNames != null)
 0176                {
 0177                    for (int j = 0; j < columnNames.Length; j++)
 0178                    {
 0179                        string nameAt = columnNames[j];
 180
 0181                        if (name == nameAt)
 0182                        {
 0183                            int columnID = columnDenseIndexToIDMap[i].TArray[j];
 184
 0185                            ref ColumnEntry columnEntry = ref columnIDToDenseIndexMap[columnID];
 0186                            return new ITable.ColumnDescription
 187                            {
 188                                InternalIndex = columnID,
 189                                Name = nameAt,
 190                                Type = columnEntry.ColumnType,
 191                            };
 192                        }
 0193                    }
 0194                }
 0195            }
 196
 0197            throw new ArgumentException("Column with name " + name + " does not exist in the table");
 0198        }
 199
 200        public ITable.ColumnDescription GetColumnDescription(int order)
 0201        {
 0202            int idAtOrderedIndex = sortedOrderToColumnIDMap[order];
 0203            ref ColumnEntry columnEntry = ref columnIDToDenseIndexMap[idAtOrderedIndex];
 204
 0205            string columnName = allColumnNames[(int)columnEntry.ColumnType][columnEntry.columnDenseIndex];
 206
 0207            return new ITable.ColumnDescription
 208            {
 209                InternalIndex = idAtOrderedIndex,
 210                Name = columnName,
 211                Type = columnEntry.ColumnType,
 212            };
 0213        }
 214
 215        public void SetAllColumnDescriptionsOrder(ITable.ColumnDescription[] orderedColumns)
 0216        {
 217            // TODO: @adam array coming in be in the new order, just use the internalIndex (stable to reorder inside her
 0218            throw new NotImplementedException();
 219        }
 220
 221        /// <inheritdoc />
 222        public ITable.ColumnDescription[] GetAllColumnDescriptions()
 0223        {
 0224            if (combinedColumnCount == 0) return null;
 0225            ITable.ColumnDescription[] returnArray = new ITable.ColumnDescription[combinedColumnCount];
 226
 0227            for (int i = 0; i < combinedColumnCount; i++)
 0228            {
 0229                int columnID = sortedOrderToColumnIDMap[i];
 0230                AssertColumnIDValid(columnID);
 0231                ref ColumnEntry entryForID = ref columnIDToDenseIndexMap[columnID];
 0232                ref ArrayHolder<string> nameColumnsForType = ref allColumnNames[(int)entryForID.ColumnType];
 233
 0234                string name = nameColumnsForType[entryForID.columnDenseIndex];
 235
 0236                returnArray[i] = new ITable.ColumnDescription
 237                {
 238                    Name = name,
 239                    InternalIndex = columnID,
 240                    Type = entryForID.ColumnType,
 241                };
 0242            }
 243
 0244            return returnArray;
 0245        }
 246
 247        internal void AssertColumnIDValid(int columnID)
 0248        {
 0249            if (columnID < 0 || columnID >= columnIDToDenseIndexMap.Length)
 0250            {
 0251                throw new ArgumentException("Invalid column outside valid ID range: " + columnID);
 252            }
 253
 0254            ref ColumnEntry columnEntry = ref columnIDToDenseIndexMap[columnID];
 255
 0256            if (columnEntry.ColumnType == Serializable.SerializableTypes.Invalid)
 0257            {
 0258                throw new ArgumentException("Invalid column pointing to deallocated entry: " + columnID);
 259            }
 0260        }
 261
 262        internal void AssertRowIDValid(int rowID)
 0263        {
 0264            if (rowID < 0 || rowID >= rowIDToDenseIndexMap.Length)
 0265            {
 0266                throw new ArgumentException("Invalid row outside valid ID range: " + rowID);
 267            }
 268
 0269            int rowIndex = rowIDToDenseIndexMap[rowID];
 270
 0271            if (rowIndex >= rowCount || rowIndex < 0)
 0272            {
 0273                throw new ArgumentException("Invalid row outside valid ID range: " + rowID);
 274            }
 0275        }
 276
 277        public void SetColumnName(string columnName, int column)
 0278        {
 0279            AssertColumnIDValid(column);
 0280            ref ColumnEntry columnEntry = ref columnIDToDenseIndexMap[column];
 0281            allColumnNames[(int)columnEntry.ColumnType][columnEntry.columnDenseIndex] = columnName;
 0282        }
 283
 284        public string GetColumnName(int column)
 0285        {
 0286            AssertColumnIDValid(column);
 0287            ref ColumnEntry columnEntry = ref columnIDToDenseIndexMap[column];
 0288            return allColumnNames[(int)columnEntry.ColumnType][columnEntry.columnDenseIndex];
 0289        }
 290
 291        public void SetRowName(string rowName, int row)
 0292        {
 0293            AssertRowIDValid(row);
 0294            int rowDenseIndex = rowIDToDenseIndexMap[row];
 0295            rowNames[rowDenseIndex] = rowName;
 0296        }
 297
 298        public string GetRowName(int row)
 0299        {
 0300            AssertRowIDValid(row);
 0301            int rowDenseIndex = rowIDToDenseIndexMap[row];
 0302            return rowNames[rowDenseIndex];
 0303        }
 304
 305        public ref string GetRowNameRef(int row)
 0306        {
 0307            AssertRowIDValid(row);
 0308            int rowDenseIndex = rowIDToDenseIndexMap[row];
 0309            return ref rowNames[rowDenseIndex];
 0310        }
 311
 312        public ref string GetColumnNameRef(int columnID)
 0313        {
 0314            AssertColumnIDValid(columnID);
 0315            ref ColumnEntry columnEntry = ref columnIDToDenseIndexMap[columnID];
 0316            return ref allColumnNames[(int)columnEntry.ColumnType][columnEntry.columnDenseIndex];
 0317        }
 318
 319
 320        public int AddRow(string rowName = null, int insertAtRowID = -1)
 0321        {
 0322            if (insertAtRowID >= 0)
 0323            {
 0324                AssertRowIDValid(insertAtRowID);
 0325            }
 0326            int rowID = rowEntriesFreeListHead;
 0327            int rowIDToDenseIndexMapLength = rowIDToDenseIndexMap?.Length ?? 0;
 0328            if (rowID >= rowIDToDenseIndexMapLength)
 0329            {
 0330                int newSize = rowID * 2;
 0331                newSize = newSize == 0 ? 1 : newSize;
 0332                Array.Resize(ref rowIDToDenseIndexMap, newSize);
 0333                for (int i = rowID; i < newSize; i++)
 0334                {
 0335                    rowIDToDenseIndexMap[i] = i + 1;
 0336                }
 0337            }
 338
 0339            int denseIndexToIDMapLength = rowDenseIndexToIDMap?.Length ?? 0;
 0340            Array.Resize(ref rowDenseIndexToIDMap, denseIndexToIDMapLength + 1);
 0341            Array.Resize(ref rowNames, denseIndexToIDMapLength + 1);
 342
 0343            int insertAt = insertAtRowID < 0 ? rowCount : rowIDToDenseIndexMap[insertAtRowID];
 344
 0345            for (int i = denseIndexToIDMapLength; i > insertAt; i--)
 0346            {
 0347                int currentRowID = rowDenseIndexToIDMap[i - 1];
 0348                rowDenseIndexToIDMap[i] = currentRowID;
 349
 0350                rowIDToDenseIndexMap[currentRowID] = i;
 351
 0352                rowNames[i] = rowNames[i - 1];
 0353            }
 354
 0355            rowEntriesFreeListHead = rowIDToDenseIndexMap[rowID];
 0356            rowIDToDenseIndexMap[rowID] = insertAt;
 0357            rowDenseIndexToIDMap[insertAt] = rowID;
 0358            rowNames[insertAt] = rowName == null ? rowID.ToString() : rowName;
 359
 0360            InsertRowsOfTypeInternal(ref allStringColumns, insertAt, 1);
 0361            InsertRowsOfTypeInternal(ref allBoolColumns, insertAt, 1);
 0362            InsertRowsOfTypeInternal(ref allCharColumns, insertAt, 1);
 0363            InsertRowsOfTypeInternal(ref allSbyteColumns, insertAt, 1);
 0364            InsertRowsOfTypeInternal(ref allByteColumns, insertAt, 1);
 0365            InsertRowsOfTypeInternal(ref allShortColumns, insertAt, 1);
 0366            InsertRowsOfTypeInternal(ref allUshortColumns, insertAt, 1);
 0367            InsertRowsOfTypeInternal(ref allIntColumns, insertAt, 1);
 0368            InsertRowsOfTypeInternal(ref allUintColumns, insertAt, 1);
 0369            InsertRowsOfTypeInternal(ref allLongColumns, insertAt, 1);
 0370            InsertRowsOfTypeInternal(ref allUlongColumns, insertAt, 1);
 0371            InsertRowsOfTypeInternal(ref allFloatColumns, insertAt, 1);
 0372            InsertRowsOfTypeInternal(ref allDoubleColumns, insertAt, 1);
 0373            InsertRowsOfTypeInternal(ref allVector2Columns, insertAt, 1);
 0374            InsertRowsOfTypeInternal(ref allVector3Columns, insertAt, 1);
 0375            InsertRowsOfTypeInternal(ref allVector4Columns, insertAt, 1);
 0376            InsertRowsOfTypeInternal(ref allVector2IntColumns, insertAt, 1);
 0377            InsertRowsOfTypeInternal(ref allVector3IntColumns, insertAt, 1);
 0378            InsertRowsOfTypeInternal(ref allQuaternionColumns, insertAt, 1);
 0379            InsertRowsOfTypeInternal(ref allRectColumns, insertAt, 1);
 0380            InsertRowsOfTypeInternal(ref allRectIntColumns, insertAt, 1);
 0381            InsertRowsOfTypeInternal(ref allColorColumns, insertAt, 1);
 0382            InsertRowsOfTypeInternal(ref allLayerMaskColumns, insertAt, 1);
 0383            InsertRowsOfTypeInternal(ref allBoundsColumns, insertAt, 1);
 0384            InsertRowsOfTypeInternal(ref allBoundsIntColumns, insertAt, 1);
 0385            InsertRowsOfTypeInternal(ref allHash128Columns, insertAt, 1);
 0386            InsertRowsOfTypeInternal(ref allGradientColumns, insertAt, 1);
 0387            InsertRowsOfTypeInternal(ref allAnimationCurveColumns, insertAt, 1);
 0388            InsertRowsOfTypeInternal(ref allObjectRefColumns, insertAt, 1);
 389
 0390            ++rowCount;
 0391            dataVersion++;
 392
 0393            return rowID;
 0394        }
 395
 396        public void AddRows(int numberOfNewRows, string[] rowNames = null, int insertAtRowID = -1)
 0397        {
 0398            if (insertAtRowID >= 0)
 0399            {
 0400                AssertRowIDValid(insertAtRowID);
 0401            }
 0402            int rowIDToDenseIndexMapLength = rowIDToDenseIndexMap?.Length ?? 0;
 0403            int newCount = rowCount + numberOfNewRows;
 0404            if (newCount > rowIDToDenseIndexMapLength)
 0405            {
 0406                int newSize = newCount;
 0407                --newSize;
 0408                newSize |= newSize >> 1;
 0409                newSize |= newSize >> 2;
 0410                newSize |= newSize >> 4;
 0411                newSize |= newSize >> 8;
 0412                newSize |= newSize >> 16;
 0413                ++newSize;
 414
 0415                newSize = newSize == 0 ? 1 : newSize;
 0416                Array.Resize(ref rowIDToDenseIndexMap, newSize);
 0417                for (int i = rowIDToDenseIndexMapLength; i < newSize; i++)
 0418                {
 0419                    rowIDToDenseIndexMap[i] = i + 1;
 0420                }
 0421            }
 422
 0423            int denseIndexToIDMapLength = rowDenseIndexToIDMap?.Length ?? 0;
 0424            Array.Resize(ref rowDenseIndexToIDMap, denseIndexToIDMapLength + numberOfNewRows);
 0425            Array.Resize(ref rowNames, denseIndexToIDMapLength + numberOfNewRows);
 426
 0427            int insertAt = insertAtRowID < 0 ? rowCount : rowIDToDenseIndexMap[insertAtRowID];
 428
 0429            for (int i = denseIndexToIDMapLength; i > insertAt + numberOfNewRows - 1; i--)
 0430            {
 0431                int currentRowID = rowDenseIndexToIDMap[i - numberOfNewRows];
 0432                rowDenseIndexToIDMap[i] = currentRowID;
 433
 0434                rowIDToDenseIndexMap[currentRowID] = i;
 435
 0436                rowNames[i] = rowNames[i - numberOfNewRows];
 0437            }
 438
 0439            int freeListHead = rowEntriesFreeListHead;
 440
 0441            for (int i = 0; i < numberOfNewRows; i++)
 0442            {
 0443                int rowID = freeListHead;
 0444                freeListHead = rowIDToDenseIndexMap[rowID];
 0445                rowIDToDenseIndexMap[rowID] = insertAt + i;
 0446                rowDenseIndexToIDMap[insertAt + i] = rowID;
 0447            }
 448
 0449            int numberOfNewRowNames = rowNames?.Length ?? 0;
 0450            string emptyString = string.Empty;
 0451            for (int i = 0; i < numberOfNewRowNames; i++)
 0452            {
 0453                string currentRowName = rowNames[i];
 0454                int rowIDAt = rowDenseIndexToIDMap[insertAt + i];
 0455                rowNames[insertAt + i] = currentRowName == null ? rowIDAt.ToString() : currentRowName;
 0456            }
 457
 0458            for (int i = numberOfNewRowNames; i < numberOfNewRows; i++)
 0459            {
 0460                int rowIDAt = rowDenseIndexToIDMap[insertAt + i];
 0461                rowNames[insertAt + i] = rowIDAt.ToString();
 0462            }
 463
 0464            rowEntriesFreeListHead = freeListHead;
 465
 0466            InsertRowsOfTypeInternal(ref allStringColumns, insertAt, numberOfNewRows);
 0467            InsertRowsOfTypeInternal(ref allBoolColumns, insertAt, numberOfNewRows);
 0468            InsertRowsOfTypeInternal(ref allCharColumns, insertAt, numberOfNewRows);
 0469            InsertRowsOfTypeInternal(ref allSbyteColumns, insertAt, numberOfNewRows);
 0470            InsertRowsOfTypeInternal(ref allByteColumns, insertAt, numberOfNewRows);
 0471            InsertRowsOfTypeInternal(ref allShortColumns, insertAt, numberOfNewRows);
 0472            InsertRowsOfTypeInternal(ref allUshortColumns, insertAt, numberOfNewRows);
 0473            InsertRowsOfTypeInternal(ref allIntColumns, insertAt, numberOfNewRows);
 0474            InsertRowsOfTypeInternal(ref allUintColumns, insertAt, numberOfNewRows);
 0475            InsertRowsOfTypeInternal(ref allLongColumns, insertAt, numberOfNewRows);
 0476            InsertRowsOfTypeInternal(ref allUlongColumns, insertAt, numberOfNewRows);
 0477            InsertRowsOfTypeInternal(ref allFloatColumns, insertAt, numberOfNewRows);
 0478            InsertRowsOfTypeInternal(ref allDoubleColumns, insertAt, numberOfNewRows);
 0479            InsertRowsOfTypeInternal(ref allVector2Columns, insertAt, numberOfNewRows);
 0480            InsertRowsOfTypeInternal(ref allVector3Columns, insertAt, numberOfNewRows);
 0481            InsertRowsOfTypeInternal(ref allVector4Columns, insertAt, numberOfNewRows);
 0482            InsertRowsOfTypeInternal(ref allVector2IntColumns, insertAt, numberOfNewRows);
 0483            InsertRowsOfTypeInternal(ref allVector3IntColumns, insertAt, numberOfNewRows);
 0484            InsertRowsOfTypeInternal(ref allQuaternionColumns, insertAt, numberOfNewRows);
 0485            InsertRowsOfTypeInternal(ref allRectColumns, insertAt, numberOfNewRows);
 0486            InsertRowsOfTypeInternal(ref allRectIntColumns, insertAt, numberOfNewRows);
 0487            InsertRowsOfTypeInternal(ref allColorColumns, insertAt, numberOfNewRows);
 0488            InsertRowsOfTypeInternal(ref allLayerMaskColumns, insertAt, numberOfNewRows);
 0489            InsertRowsOfTypeInternal(ref allBoundsColumns, insertAt, numberOfNewRows);
 0490            InsertRowsOfTypeInternal(ref allBoundsIntColumns, insertAt, numberOfNewRows);
 0491            InsertRowsOfTypeInternal(ref allHash128Columns, insertAt, numberOfNewRows);
 0492            InsertRowsOfTypeInternal(ref allGradientColumns, insertAt, numberOfNewRows);
 0493            InsertRowsOfTypeInternal(ref allAnimationCurveColumns, insertAt, numberOfNewRows);
 0494            InsertRowsOfTypeInternal(ref allObjectRefColumns, insertAt, numberOfNewRows);
 495
 0496            rowCount += numberOfNewRows;
 0497            dataVersion++;
 0498        }
 499
 500        public void AddRows(int numberOfNewRows, ref int[] rowIDs, string[] rowNames = null, int insertAtRowID = -1)
 0501        {
 0502            if (insertAtRowID >= 0)
 0503            {
 0504                AssertRowIDValid(insertAtRowID);
 0505            }
 0506            int rowIDToDenseIndexMapLength = rowIDToDenseIndexMap?.Length ?? 0;
 0507            int newCount = rowCount + numberOfNewRows;
 0508            if (newCount > rowIDToDenseIndexMapLength)
 0509            {
 0510                int newSize = newCount;
 0511                --newSize;
 0512                newSize |= newSize >> 1;
 0513                newSize |= newSize >> 2;
 0514                newSize |= newSize >> 4;
 0515                newSize |= newSize >> 8;
 0516                newSize |= newSize >> 16;
 0517                ++newSize;
 518
 0519                newSize = newSize == 0 ? 1 : newSize;
 0520                Array.Resize(ref rowIDToDenseIndexMap, newSize);
 0521                for (int i = rowIDToDenseIndexMapLength; i < newSize; i++)
 0522                {
 0523                    rowIDToDenseIndexMap[i] = i + 1;
 0524                }
 0525            }
 526
 0527            int denseIndexToIDMapLength = rowDenseIndexToIDMap?.Length ?? 0;
 0528            Array.Resize(ref rowDenseIndexToIDMap, denseIndexToIDMapLength + numberOfNewRows);
 529
 0530            int insertAt = insertAtRowID < 0 ? rowCount : rowIDToDenseIndexMap[insertAtRowID];
 531
 0532            for (int i = denseIndexToIDMapLength; i > insertAt + numberOfNewRows - 1; i--)
 0533            {
 0534                int currentRowID = rowDenseIndexToIDMap[i - numberOfNewRows];
 0535                rowDenseIndexToIDMap[i] = currentRowID;
 536
 0537                rowIDToDenseIndexMap[currentRowID] = i;
 538
 0539                rowNames[i] = rowNames[i - numberOfNewRows];
 0540            }
 541
 0542            int freeListHead = rowEntriesFreeListHead;
 543
 0544            for (int i = 0; i < numberOfNewRows; i++)
 0545            {
 0546                int rowID = freeListHead;
 0547                freeListHead = rowIDToDenseIndexMap[rowID];
 0548                rowIDToDenseIndexMap[rowID] = insertAt + i;
 0549                rowDenseIndexToIDMap[insertAt + i] = rowID;
 0550                rowIDs[i] = rowID;
 0551            }
 552
 0553            int numberOfNewRowNames = rowNames?.Length ?? 0;
 0554            for (int i = 0; i < numberOfNewRowNames; i++)
 0555            {
 0556                string currentRowName = rowNames[i];
 0557                int rowIDAt = rowDenseIndexToIDMap[insertAt + i];
 0558                rowNames[insertAt + i] = currentRowName == null ? rowIDAt.ToString() : currentRowName;
 0559            }
 560
 0561            for (int i = numberOfNewRowNames; i < numberOfNewRows; i++)
 0562            {
 0563                int rowIDAt = rowDenseIndexToIDMap[insertAt + i];
 0564                rowNames[insertAt + i] = rowIDAt.ToString();
 0565            }
 566
 0567            rowEntriesFreeListHead = freeListHead;
 568
 0569            InsertRowsOfTypeInternal(ref allStringColumns, insertAt, numberOfNewRows);
 0570            InsertRowsOfTypeInternal(ref allBoolColumns, insertAt, numberOfNewRows);
 0571            InsertRowsOfTypeInternal(ref allCharColumns, insertAt, numberOfNewRows);
 0572            InsertRowsOfTypeInternal(ref allSbyteColumns, insertAt, numberOfNewRows);
 0573            InsertRowsOfTypeInternal(ref allByteColumns, insertAt, numberOfNewRows);
 0574            InsertRowsOfTypeInternal(ref allShortColumns, insertAt, numberOfNewRows);
 0575            InsertRowsOfTypeInternal(ref allUshortColumns, insertAt, numberOfNewRows);
 0576            InsertRowsOfTypeInternal(ref allIntColumns, insertAt, numberOfNewRows);
 0577            InsertRowsOfTypeInternal(ref allUintColumns, insertAt, numberOfNewRows);
 0578            InsertRowsOfTypeInternal(ref allLongColumns, insertAt, numberOfNewRows);
 0579            InsertRowsOfTypeInternal(ref allUlongColumns, insertAt, numberOfNewRows);
 0580            InsertRowsOfTypeInternal(ref allFloatColumns, insertAt, numberOfNewRows);
 0581            InsertRowsOfTypeInternal(ref allDoubleColumns, insertAt, numberOfNewRows);
 0582            InsertRowsOfTypeInternal(ref allVector2Columns, insertAt, numberOfNewRows);
 0583            InsertRowsOfTypeInternal(ref allVector3Columns, insertAt, numberOfNewRows);
 0584            InsertRowsOfTypeInternal(ref allVector4Columns, insertAt, numberOfNewRows);
 0585            InsertRowsOfTypeInternal(ref allVector2IntColumns, insertAt, numberOfNewRows);
 0586            InsertRowsOfTypeInternal(ref allVector3IntColumns, insertAt, numberOfNewRows);
 0587            InsertRowsOfTypeInternal(ref allQuaternionColumns, insertAt, numberOfNewRows);
 0588            InsertRowsOfTypeInternal(ref allRectColumns, insertAt, numberOfNewRows);
 0589            InsertRowsOfTypeInternal(ref allRectIntColumns, insertAt, numberOfNewRows);
 0590            InsertRowsOfTypeInternal(ref allColorColumns, insertAt, numberOfNewRows);
 0591            InsertRowsOfTypeInternal(ref allLayerMaskColumns, insertAt, numberOfNewRows);
 0592            InsertRowsOfTypeInternal(ref allBoundsColumns, insertAt, numberOfNewRows);
 0593            InsertRowsOfTypeInternal(ref allBoundsIntColumns, insertAt, numberOfNewRows);
 0594            InsertRowsOfTypeInternal(ref allHash128Columns, insertAt, numberOfNewRows);
 0595            InsertRowsOfTypeInternal(ref allGradientColumns, insertAt, numberOfNewRows);
 0596            InsertRowsOfTypeInternal(ref allAnimationCurveColumns, insertAt, numberOfNewRows);
 0597            InsertRowsOfTypeInternal(ref allObjectRefColumns, insertAt, numberOfNewRows);
 598
 0599            rowCount += numberOfNewRows;
 0600            dataVersion++;
 0601        }
 602
 603        public void RemoveRow(int rowID)
 0604        {
 0605            AssertRowIDValid(rowID);
 0606            int rowDenseIndex = rowIDToDenseIndexMap[rowID];
 0607            for (int i = rowDenseIndex + 1; i < rowCount; i++)
 0608            {
 0609                int currentRowID = rowDenseIndexToIDMap[i];
 0610                rowIDToDenseIndexMap[currentRowID] = i - 1;
 0611                rowDenseIndexToIDMap[i - 1] = currentRowID;
 0612                rowNames[i - 1] = rowNames[i];
 0613            }
 614
 0615            rowIDToDenseIndexMap[rowID] = rowEntriesFreeListHead;
 0616            rowEntriesFreeListHead = rowID;
 0617            Array.Resize(ref rowDenseIndexToIDMap, rowCount - 1);
 0618            Array.Resize(ref rowNames, rowCount - 1);
 619
 0620            DeleteRowsOfTypeInternal(ref allStringColumns, rowID, 1);
 0621            DeleteRowsOfTypeInternal(ref allBoolColumns, rowID, 1);
 0622            DeleteRowsOfTypeInternal(ref allCharColumns, rowID, 1);
 0623            DeleteRowsOfTypeInternal(ref allSbyteColumns, rowID, 1);
 0624            DeleteRowsOfTypeInternal(ref allByteColumns, rowID, 1);
 0625            DeleteRowsOfTypeInternal(ref allShortColumns, rowID, 1);
 0626            DeleteRowsOfTypeInternal(ref allUshortColumns, rowID, 1);
 0627            DeleteRowsOfTypeInternal(ref allIntColumns, rowID, 1);
 0628            DeleteRowsOfTypeInternal(ref allUintColumns, rowID, 1);
 0629            DeleteRowsOfTypeInternal(ref allLongColumns, rowID, 1);
 0630            DeleteRowsOfTypeInternal(ref allUlongColumns, rowID, 1);
 0631            DeleteRowsOfTypeInternal(ref allFloatColumns, rowID, 1);
 0632            DeleteRowsOfTypeInternal(ref allDoubleColumns, rowID, 1);
 0633            DeleteRowsOfTypeInternal(ref allVector2Columns, rowID, 1);
 0634            DeleteRowsOfTypeInternal(ref allVector3Columns, rowID, 1);
 0635            DeleteRowsOfTypeInternal(ref allVector4Columns, rowID, 1);
 0636            DeleteRowsOfTypeInternal(ref allVector2IntColumns, rowID, 1);
 0637            DeleteRowsOfTypeInternal(ref allVector3IntColumns, rowID, 1);
 0638            DeleteRowsOfTypeInternal(ref allQuaternionColumns, rowID, 1);
 0639            DeleteRowsOfTypeInternal(ref allRectColumns, rowID, 1);
 0640            DeleteRowsOfTypeInternal(ref allRectIntColumns, rowID, 1);
 0641            DeleteRowsOfTypeInternal(ref allColorColumns, rowID, 1);
 0642            DeleteRowsOfTypeInternal(ref allLayerMaskColumns, rowID, 1);
 0643            DeleteRowsOfTypeInternal(ref allBoundsColumns, rowID, 1);
 0644            DeleteRowsOfTypeInternal(ref allBoundsIntColumns, rowID, 1);
 0645            DeleteRowsOfTypeInternal(ref allHash128Columns, rowID, 1);
 0646            DeleteRowsOfTypeInternal(ref allGradientColumns, rowID, 1);
 0647            DeleteRowsOfTypeInternal(ref allAnimationCurveColumns, rowID, 1);
 0648            DeleteRowsOfTypeInternal(ref allObjectRefColumns, rowID, 1);
 649
 0650            --rowCount;
 0651            dataVersion++;
 0652        }
 653
 654        public int AddColumn(Serializable.SerializableTypes columnType, string columnName, int insertAtColumnID = -1)
 0655        {
 0656            switch (columnType)
 657            {
 658                case Serializable.SerializableTypes.String:
 0659                    return AddColumnInternal(columnName, ref allStringColumns, Serializable.SerializableTypes.String, in
 660                case Serializable.SerializableTypes.Char:
 0661                    return AddColumnInternal(columnName, ref allCharColumns, Serializable.SerializableTypes.Char, insert
 662                case Serializable.SerializableTypes.Bool:
 0663                    return AddColumnInternal(columnName, ref allBoolColumns, Serializable.SerializableTypes.Bool, insert
 664                case Serializable.SerializableTypes.SByte:
 0665                    return AddColumnInternal(columnName, ref allSbyteColumns, Serializable.SerializableTypes.SByte, inse
 666                case Serializable.SerializableTypes.Byte:
 0667                    return AddColumnInternal(columnName, ref allByteColumns, Serializable.SerializableTypes.Byte, insert
 668                case Serializable.SerializableTypes.Short:
 0669                    return AddColumnInternal(columnName, ref allShortColumns, Serializable.SerializableTypes.Short, inse
 670                case Serializable.SerializableTypes.UShort:
 0671                    return AddColumnInternal(columnName, ref allUshortColumns, Serializable.SerializableTypes.UShort, in
 672                case Serializable.SerializableTypes.Int:
 0673                    return AddColumnInternal(columnName, ref allIntColumns, Serializable.SerializableTypes.Int, insertAt
 674                case Serializable.SerializableTypes.UInt:
 0675                    return AddColumnInternal(columnName, ref allUintColumns, Serializable.SerializableTypes.UInt, insert
 676                case Serializable.SerializableTypes.Long:
 0677                    return AddColumnInternal(columnName, ref allLongColumns, Serializable.SerializableTypes.Long, insert
 678                case Serializable.SerializableTypes.ULong:
 0679                    return AddColumnInternal(columnName, ref allUlongColumns, Serializable.SerializableTypes.ULong, inse
 680                case Serializable.SerializableTypes.Float:
 0681                    return AddColumnInternal(columnName, ref allFloatColumns, Serializable.SerializableTypes.Float, inse
 682                case Serializable.SerializableTypes.Double:
 0683                    return AddColumnInternal(columnName, ref allDoubleColumns, Serializable.SerializableTypes.Double, in
 684                case Serializable.SerializableTypes.Vector2:
 0685                    return AddColumnInternal(columnName, ref allVector2Columns, Serializable.SerializableTypes.Vector2, 
 686                case Serializable.SerializableTypes.Vector3:
 0687                    return AddColumnInternal(columnName, ref allVector3Columns, Serializable.SerializableTypes.Vector3, 
 688                case Serializable.SerializableTypes.Vector4:
 0689                    return AddColumnInternal(columnName, ref allVector4Columns, Serializable.SerializableTypes.Vector4, 
 690                case Serializable.SerializableTypes.Vector2Int:
 0691                    return AddColumnInternal(columnName, ref allVector2IntColumns, Serializable.SerializableTypes.Vector
 692                case Serializable.SerializableTypes.Vector3Int:
 0693                    return AddColumnInternal(columnName, ref allVector3IntColumns, Serializable.SerializableTypes.Vector
 694                case Serializable.SerializableTypes.Quaternion:
 0695                    return AddColumnInternal(columnName, ref allQuaternionColumns, Serializable.SerializableTypes.Quater
 696                case Serializable.SerializableTypes.Rect:
 0697                    return AddColumnInternal(columnName, ref allRectColumns, Serializable.SerializableTypes.Rect, insert
 698                case Serializable.SerializableTypes.RectInt:
 0699                    return AddColumnInternal(columnName, ref allRectIntColumns, Serializable.SerializableTypes.RectInt, 
 700                case Serializable.SerializableTypes.Color:
 0701                    return AddColumnInternal(columnName, ref allColorColumns, Serializable.SerializableTypes.Color, inse
 702                case Serializable.SerializableTypes.LayerMask:
 0703                    return AddColumnInternal(columnName, ref allLayerMaskColumns, Serializable.SerializableTypes.LayerMa
 704                case Serializable.SerializableTypes.Bounds:
 0705                    return AddColumnInternal(columnName, ref allBoundsColumns, Serializable.SerializableTypes.Bounds, in
 706                case Serializable.SerializableTypes.BoundsInt:
 0707                    return AddColumnInternal(columnName, ref allBoundsIntColumns, Serializable.SerializableTypes.BoundsI
 708                case Serializable.SerializableTypes.Hash128:
 0709                    return AddColumnInternal(columnName, ref allHash128Columns, Serializable.SerializableTypes.Hash128, 
 710                case Serializable.SerializableTypes.Gradient:
 0711                    return AddColumnInternal(columnName, ref allGradientColumns, Serializable.SerializableTypes.Gradient
 712                case Serializable.SerializableTypes.AnimationCurve:
 0713                    return AddColumnInternal(columnName, ref allAnimationCurveColumns, Serializable.SerializableTypes.An
 714                case Serializable.SerializableTypes.Object:
 0715                    return AddColumnInternal(columnName, ref allObjectRefColumns, Serializable.SerializableTypes.Object,
 716            }
 0717            return -1;
 0718        }
 719
 720        public void RemoveColumn(Serializable.SerializableTypes columnType, int columnID)
 0721        {
 0722            switch (columnType)
 723            {
 724                case Serializable.SerializableTypes.String:
 0725                    RemoveColumnInternal(ref allStringColumns, Serializable.SerializableTypes.String, columnID);
 0726                    break;
 727                case Serializable.SerializableTypes.Char:
 0728                    RemoveColumnInternal(ref allCharColumns, Serializable.SerializableTypes.Char, columnID);
 0729                    break;
 730                case Serializable.SerializableTypes.Bool:
 0731                    RemoveColumnInternal(ref allBoolColumns, Serializable.SerializableTypes.Bool, columnID);
 0732                    break;
 733                case Serializable.SerializableTypes.SByte:
 0734                    RemoveColumnInternal(ref allSbyteColumns, Serializable.SerializableTypes.SByte, columnID);
 0735                    break;
 736                case Serializable.SerializableTypes.Byte:
 0737                    RemoveColumnInternal(ref allByteColumns, Serializable.SerializableTypes.Byte, columnID);
 0738                    break;
 739                case Serializable.SerializableTypes.Short:
 0740                    RemoveColumnInternal(ref allShortColumns, Serializable.SerializableTypes.Short, columnID);
 0741                    break;
 742                case Serializable.SerializableTypes.UShort:
 0743                    RemoveColumnInternal(ref allUshortColumns, Serializable.SerializableTypes.UShort, columnID);
 0744                    break;
 745                case Serializable.SerializableTypes.Int:
 0746                    RemoveColumnInternal(ref allIntColumns, Serializable.SerializableTypes.Int, columnID);
 0747                    break;
 748                case Serializable.SerializableTypes.UInt:
 0749                    RemoveColumnInternal(ref allUintColumns, Serializable.SerializableTypes.UInt, columnID);
 0750                    break;
 751                case Serializable.SerializableTypes.Long:
 0752                    RemoveColumnInternal(ref allLongColumns, Serializable.SerializableTypes.Long, columnID);
 0753                    break;
 754                case Serializable.SerializableTypes.ULong:
 0755                    RemoveColumnInternal(ref allUlongColumns, Serializable.SerializableTypes.ULong, columnID);
 0756                    break;
 757                case Serializable.SerializableTypes.Float:
 0758                    RemoveColumnInternal(ref allFloatColumns, Serializable.SerializableTypes.Float, columnID);
 0759                    break;
 760                case Serializable.SerializableTypes.Double:
 0761                    RemoveColumnInternal(ref allDoubleColumns, Serializable.SerializableTypes.Double, columnID);
 0762                    break;
 763                case Serializable.SerializableTypes.Vector2:
 0764                    RemoveColumnInternal(ref allVector2Columns, Serializable.SerializableTypes.Vector2, columnID);
 0765                    break;
 766                case Serializable.SerializableTypes.Vector3:
 0767                    RemoveColumnInternal(ref allVector3Columns, Serializable.SerializableTypes.Vector3, columnID);
 0768                    break;
 769                case Serializable.SerializableTypes.Vector4:
 0770                    RemoveColumnInternal(ref allVector4Columns, Serializable.SerializableTypes.Vector4, columnID);
 0771                    break;
 772                case Serializable.SerializableTypes.Vector2Int:
 0773                    RemoveColumnInternal(ref allVector2IntColumns, Serializable.SerializableTypes.Vector2Int, columnID);
 0774                    break;
 775                case Serializable.SerializableTypes.Vector3Int:
 0776                    RemoveColumnInternal(ref allVector3IntColumns, Serializable.SerializableTypes.Vector3Int, columnID);
 0777                    break;
 778                case Serializable.SerializableTypes.Quaternion:
 0779                    RemoveColumnInternal(ref allQuaternionColumns, Serializable.SerializableTypes.Quaternion, columnID);
 0780                    break;
 781                case Serializable.SerializableTypes.Rect:
 0782                    RemoveColumnInternal(ref allRectColumns, Serializable.SerializableTypes.Rect, columnID);
 0783                    break;
 784                case Serializable.SerializableTypes.RectInt:
 0785                    RemoveColumnInternal(ref allRectIntColumns, Serializable.SerializableTypes.RectInt, columnID);
 0786                    break;
 787                case Serializable.SerializableTypes.Color:
 0788                    RemoveColumnInternal(ref allColorColumns, Serializable.SerializableTypes.Color, columnID);
 0789                    break;
 790                case Serializable.SerializableTypes.LayerMask:
 0791                    RemoveColumnInternal(ref allLayerMaskColumns, Serializable.SerializableTypes.LayerMask, columnID);
 0792                    break;
 793                case Serializable.SerializableTypes.Bounds:
 0794                    RemoveColumnInternal(ref allBoundsColumns, Serializable.SerializableTypes.Bounds, columnID);
 0795                    break;
 796                case Serializable.SerializableTypes.BoundsInt:
 0797                    RemoveColumnInternal(ref allBoundsIntColumns, Serializable.SerializableTypes.BoundsInt, columnID);
 0798                    break;
 799                case Serializable.SerializableTypes.Hash128:
 0800                    RemoveColumnInternal(ref allHash128Columns, Serializable.SerializableTypes.Hash128, columnID);
 0801                    break;
 802                case Serializable.SerializableTypes.Gradient:
 0803                    RemoveColumnInternal(ref allGradientColumns, Serializable.SerializableTypes.Gradient, columnID);
 0804                    break;
 805                case Serializable.SerializableTypes.AnimationCurve:
 0806                    RemoveColumnInternal(ref allAnimationCurveColumns, Serializable.SerializableTypes.AnimationCurve, co
 0807                    break;
 808                case Serializable.SerializableTypes.Object:
 0809                    RemoveColumnInternal(ref allObjectRefColumns, Serializable.SerializableTypes.Object, columnID);
 0810                    break;
 811            }
 0812        }
 813
 814        // Set
 815
 816        public ulong SetString(int row, int column, string value)
 0817        {
 0818            return SetCell(row, column, ref allStringColumns, value);
 0819        }
 820
 821        public ulong SetBool(int row, int column, bool value)
 0822        {
 0823            return SetCell(row, column, ref allBoolColumns, value);
 0824        }
 825
 826        public ulong SetChar(int row, int column, char value)
 0827        {
 0828            return SetCell(row, column, ref allCharColumns, value);
 0829        }
 830
 831        public ulong SetSByte(int row, int column, sbyte value)
 0832        {
 0833            return SetCell(row, column, ref allSbyteColumns, value);
 0834        }
 835
 836        public ulong SetByte(int row, int column, byte value)
 0837        {
 0838            return SetCell(row, column, ref allByteColumns, value);
 0839        }
 840
 841        public ulong SetShort(int row, int column, short value)
 0842        {
 0843            return SetCell(row, column, ref allShortColumns, value);
 0844        }
 845
 846        public ulong SetUShort(int row, int column, ushort value)
 0847        {
 0848            return SetCell(row, column, ref allUshortColumns, value);
 0849        }
 850
 851        public ulong SetInt(int row, int column, int value)
 0852        {
 0853            return SetCell(row, column, ref allIntColumns, value);
 0854        }
 855
 856        public ulong SetUInt(int row, int column, uint value)
 0857        {
 0858            return SetCell(row, column, ref allUintColumns, value);
 0859        }
 860
 861        public ulong SetLong(int row, int column, long value)
 0862        {
 0863            return SetCell(row, column, ref allLongColumns, value);
 0864        }
 865
 866        public ulong SetULong(int row, int column, ulong value)
 0867        {
 0868            return SetCell(row, column, ref allUlongColumns, value);
 0869        }
 870
 871        public ulong SetFloat(int row, int column, float value)
 0872        {
 0873            return SetCell(row, column, ref allFloatColumns, value);
 0874        }
 875
 876        public ulong SetDouble(int row, int column, double value)
 0877        {
 0878            return SetCell(row, column, ref allDoubleColumns, value);
 0879        }
 880
 881        public ulong SetVector2(int row, int column, Vector2 value)
 0882        {
 0883            return SetCell(row, column, ref allVector2Columns, value);
 0884        }
 885
 886        public ulong SetVector3(int row, int column, Vector3 value)
 0887        {
 0888            return SetCell(row, column, ref allVector3Columns, value);
 0889        }
 890
 891        public ulong SetVector4(int row, int column, Vector4 value)
 0892        {
 0893            return SetCell(row, column, ref allVector4Columns, value);
 0894        }
 895
 896        public ulong SetVector2Int(int row, int column, Vector2Int value)
 0897        {
 0898            return SetCell(row, column, ref allVector2IntColumns, value);
 0899        }
 900
 901        public ulong SetVector3Int(int row, int column, Vector3Int value)
 0902        {
 0903            return SetCell(row, column, ref allVector3IntColumns, value);
 0904        }
 905
 906        public ulong SetQuaternion(int row, int column, Quaternion value)
 0907        {
 0908            return SetCell(row, column, ref allQuaternionColumns, value);
 0909        }
 910
 911        public ulong SetRect(int row, int column, Rect value)
 0912        {
 0913            return SetCell(row, column, ref allRectColumns, value);
 0914        }
 915
 916        public ulong SetRectInt(int row, int column, RectInt value)
 0917        {
 0918            return SetCell(row, column, ref allRectIntColumns, value);
 0919        }
 920
 921        public ulong SetColor(int row, int column, Color value)
 0922        {
 0923            return SetCell(row, column, ref allColorColumns, value);
 0924        }
 925
 926        public ulong SetLayerMask(int row, int column, LayerMask value)
 0927        {
 0928            return SetCell(row, column, ref allLayerMaskColumns, value);
 0929        }
 930
 931        public ulong SetBounds(int row, int column, Bounds value)
 0932        {
 0933            return SetCell(row, column, ref allBoundsColumns, value);
 0934        }
 935
 936        public ulong SetBoundsInt(int row, int column, BoundsInt value)
 0937        {
 0938            return SetCell(row, column, ref allBoundsIntColumns, value);
 0939        }
 940
 941        public ulong SetHash128(int row, int column, Hash128 value)
 0942        {
 0943            return SetCell(row, column, ref allHash128Columns, value);
 0944        }
 945
 946        public ulong SetGradient(int row, int column, Gradient value)
 0947        {
 0948            return SetCell(row, column, ref allGradientColumns, value);
 0949        }
 950
 951        public ulong SetAnimationCurve(int row, int column, AnimationCurve value)
 0952        {
 0953            return SetCell(row, column, ref allAnimationCurveColumns, value);
 0954        }
 955
 956        public ulong SetObject(int row, int column, UnityEngine.Object value)
 0957        {
 0958            return SetCell(row, column, ref allObjectRefColumns, value);
 0959        }
 960
 961        public void SetTypeNameForObjectColumn<T>(int columnID) where T : UnityEngine.Object
 0962        {
 0963            AssertObjectColumnIDValid(columnID);
 0964            int denseIndex = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 0965            allObjectRefTypenames[denseIndex] = typeof(T).AssemblyQualifiedName;
 0966        }
 967
 968        // Get
 969        public string GetString(int row, int column)
 0970        {
 0971            return GetCell(row, column, ref allStringColumns);
 0972        }
 973
 974        public bool GetBool(int row, int column)
 0975        {
 0976            return GetCell(row, column, ref allBoolColumns);
 0977        }
 978
 979        public char GetChar(int row, int column)
 0980        {
 0981            return GetCell(row, column, ref allCharColumns);
 0982        }
 983
 984        public sbyte GetSByte(int row, int column)
 0985        {
 0986            return GetCell(row, column, ref allSbyteColumns);
 0987        }
 988
 989        public byte GetByte(int row, int column)
 0990        {
 0991            return GetCell(row, column, ref allByteColumns);
 0992        }
 993
 994        public short GetShort(int row, int column)
 0995        {
 0996            return GetCell(row, column, ref allShortColumns);
 0997        }
 998
 999        public ushort GetUShort(int row, int column)
 01000        {
 01001            return GetCell(row, column, ref allUshortColumns);
 01002        }
 1003
 1004        public int GetInt(int row, int column)
 01005        {
 01006            return GetCell(row, column, ref allIntColumns);
 01007        }
 1008
 1009        public uint GetUInt(int row, int column)
 01010        {
 01011            return GetCell(row, column, ref allUintColumns);
 01012        }
 1013
 1014        public long GetLong(int row, int column)
 01015        {
 01016            return GetCell(row, column, ref allLongColumns);
 01017        }
 1018
 1019        public ulong GetULong(int row, int column)
 01020        {
 01021            return GetCell(row, column, ref allUlongColumns);
 01022        }
 1023
 1024        public float GetFloat(int row, int column)
 01025        {
 01026            return GetCell(row, column, ref allFloatColumns);
 01027        }
 1028
 1029        public double GetDouble(int row, int column)
 01030        {
 01031            return GetCell(row, column, ref allDoubleColumns);
 01032        }
 1033
 1034        public Vector2 GetVector2(int row, int column)
 01035        {
 01036            return GetCell(row, column, ref allVector2Columns);
 01037        }
 1038
 1039        public Vector3 GetVector3(int row, int column)
 01040        {
 01041            return GetCell(row, column, ref allVector3Columns);
 01042        }
 1043
 1044        public Vector4 GetVector4(int row, int column)
 01045        {
 01046            return GetCell(row, column, ref allVector4Columns);
 01047        }
 1048
 1049        public Vector2Int GetVector2Int(int row, int column)
 01050        {
 01051            return GetCell(row, column, ref allVector2IntColumns);
 01052        }
 1053
 1054        public Vector3Int GetVector3Int(int row, int column)
 01055        {
 01056            return GetCell(row, column, ref allVector3IntColumns);
 01057        }
 1058
 1059        public Quaternion GetQuaternion(int row, int column)
 01060        {
 01061            return GetCell(row, column, ref allQuaternionColumns);
 01062        }
 1063
 1064        public Rect GetRect(int row, int column)
 01065        {
 01066            return GetCell(row, column, ref allRectColumns);
 01067        }
 1068
 1069        public RectInt GetRectInt(int row, int column)
 01070        {
 01071            return GetCell(row, column, ref allRectIntColumns);
 01072        }
 1073
 1074        public Color GetColor(int row, int column)
 01075        {
 01076            return GetCell(row, column, ref allColorColumns);
 01077        }
 1078
 1079        public LayerMask GetLayerMask(int row, int column)
 01080        {
 01081            return GetCell(row, column, ref allLayerMaskColumns);
 01082        }
 1083
 1084        public Bounds GetBounds(int row, int column)
 01085        {
 01086            return GetCell(row, column, ref allBoundsColumns);
 01087        }
 1088
 1089        public BoundsInt GetBoundsInt(int row, int column)
 01090        {
 01091            return GetCell(row, column, ref allBoundsIntColumns);
 01092        }
 1093
 1094        public Hash128 GetHash128(int row, int column)
 01095        {
 01096            return GetCell(row, column, ref allHash128Columns);
 01097        }
 1098
 1099        public Gradient GetGradient(int row, int column)
 01100        {
 01101            return GetCell(row, column, ref allGradientColumns);
 01102        }
 1103
 1104        public AnimationCurve GetAnimationCurve(int row, int column)
 01105        {
 01106            return GetCell(row, column, ref allAnimationCurveColumns);
 01107        }
 1108
 1109        public UnityEngine.Object GetObject(int row, int column)
 01110        {
 01111            return GetCell(row, column, ref allObjectRefColumns);
 01112        }
 1113
 1114        // Get ref
 1115
 1116        public ref string GetStringRef(int row, int column)
 01117        {
 01118            return ref GetCellRef(row, column, ref allStringColumns);
 01119        }
 1120
 1121        public ref bool GetBoolRef(int row, int column)
 01122        {
 01123            return ref GetCellRef(row, column, ref allBoolColumns);
 01124        }
 1125
 1126        public ref char GetCharRef(int row, int column)
 01127        {
 01128            return ref GetCellRef(row, column, ref allCharColumns);
 01129        }
 1130
 1131        public ref sbyte GetSbyteRef(int row, int column)
 01132        {
 01133            return ref GetCellRef(row, column, ref allSbyteColumns);
 01134        }
 1135
 1136        public ref byte GetByteRef(int row, int columnID)
 01137        {
 01138            return ref GetCellRef(row, columnID, ref allByteColumns);
 01139        }
 1140
 1141        public ref short GetShortRef(int row, int column)
 01142        {
 01143            return ref GetCellRef(row, column, ref allShortColumns);
 01144        }
 1145
 1146        public ref ushort GetUshortRef(int row, int column)
 01147        {
 01148            return ref GetCellRef(row, column, ref allUshortColumns);
 01149        }
 1150
 1151        public ref int GetIntRef(int row, int column)
 01152        {
 01153            return ref GetCellRef(row, column, ref allIntColumns);
 01154        }
 1155
 1156        public ref uint GetUintRef(int row, int column)
 01157        {
 01158            return ref GetCellRef(row, column, ref allUintColumns);
 01159        }
 1160
 1161        public ref long GetLongRef(int row, int column)
 01162        {
 01163            return ref GetCellRef(row, column, ref allLongColumns);
 01164        }
 1165
 1166        public ref ulong GetUlongRef(int row, int column)
 01167        {
 01168            return ref GetCellRef(row, column, ref allUlongColumns);
 01169        }
 1170
 1171        public ref float GetFloatRef(int row, int column)
 01172        {
 01173            return ref GetCellRef(row, column, ref allFloatColumns);
 01174        }
 1175
 1176        public ref double GetDoubleRef(int row, int column)
 01177        {
 01178            return ref GetCellRef(row, column, ref allDoubleColumns);
 01179        }
 1180
 1181        public ref Vector2 GetVector2Ref(int row, int column)
 01182        {
 01183            return ref GetCellRef(row, column, ref allVector2Columns);
 01184        }
 1185
 1186        public ref Vector3 GetVector3Ref(int row, int column)
 01187        {
 01188            return ref GetCellRef(row, column, ref allVector3Columns);
 01189        }
 1190
 1191        public ref Vector4 GetVector4Ref(int row, int column)
 01192        {
 01193            return ref GetCellRef(row, column, ref allVector4Columns);
 01194        }
 1195
 1196        public ref Vector2Int GetVector2IntRef(int row, int column)
 01197        {
 01198            return ref GetCellRef(row, column, ref allVector2IntColumns);
 01199        }
 1200
 1201        public ref Vector3Int GetVector3IntRef(int row, int column)
 01202        {
 01203            return ref GetCellRef(row, column, ref allVector3IntColumns);
 01204        }
 1205
 1206        public ref Quaternion GetQuaternionRef(int row, int column)
 01207        {
 01208            return ref GetCellRef(row, column, ref allQuaternionColumns);
 01209        }
 1210
 1211        public ref Rect GetRectRef(int row, int column)
 01212        {
 01213            return ref GetCellRef(row, column, ref allRectColumns);
 01214        }
 1215
 1216        public ref RectInt GetRectIntRef(int row, int column)
 01217        {
 01218            return ref GetCellRef(row, column, ref allRectIntColumns);
 01219        }
 1220
 1221        public ref Color GetColorRef(int row, int column)
 01222        {
 01223            return ref GetCellRef(row, column, ref allColorColumns);
 01224        }
 1225
 1226        public ref LayerMask GetLayerMaskRef(int row, int column)
 01227        {
 01228            return ref GetCellRef(row, column, ref allLayerMaskColumns);
 01229        }
 1230
 1231        public ref Bounds GetBoundsRef(int row, int column)
 01232        {
 01233            return ref GetCellRef(row, column, ref allBoundsColumns);
 01234        }
 1235
 1236        public ref BoundsInt GetBoundsIntRef(int row, int column)
 01237        {
 01238            return ref GetCellRef(row, column, ref allBoundsIntColumns);
 01239        }
 1240
 1241        public ref Hash128 GetHash128Ref(int row, int column)
 01242        {
 01243            return ref GetCellRef(row, column, ref allHash128Columns);
 01244        }
 1245
 1246        public ref Gradient GetGradientRef(int row, int column)
 01247        {
 01248            return ref GetCellRef(row, column, ref allGradientColumns);
 01249        }
 1250
 1251        public ref AnimationCurve GetAnimationCurveRef(int row, int column)
 01252        {
 01253            return ref GetCellRef(row, column, ref allAnimationCurveColumns);
 01254        }
 1255
 1256        public ref UnityEngine.Object GetObjectRef(int row, int column)
 01257        {
 01258            return ref GetCellRef(row, column, ref allObjectRefColumns);
 01259        }
 1260
 1261        // Get Column
 1262
 1263        public string[] GetStringColumn(int column)
 01264        {
 01265            return GetColumn(column, ref allStringColumns);
 01266        }
 1267
 1268        public bool[] GetBoolColumn(int column)
 01269        {
 01270            return GetColumn(column, ref allBoolColumns);
 01271        }
 1272
 1273        public char[] GetCharColumn(int column)
 01274        {
 01275            return GetColumn(column, ref allCharColumns);
 01276        }
 1277
 1278        public sbyte[] GetSbyteColumn(int column)
 01279        {
 01280            return GetColumn(column, ref allSbyteColumns);
 01281        }
 1282
 1283        public byte[] GetByteColumn(int column)
 01284        {
 01285            return GetColumn(column, ref allByteColumns);
 01286        }
 1287
 1288        public short[] GetShortColumn(int column)
 01289        {
 01290            return GetColumn(column, ref allShortColumns);
 01291        }
 1292
 1293        public ushort[] GetUshortColumn(int column)
 01294        {
 01295            return GetColumn(column, ref allUshortColumns);
 01296        }
 1297
 1298        public int[] GetIntColumn(int column)
 01299        {
 01300            return GetColumn(column, ref allIntColumns);
 01301        }
 1302
 1303        public uint[] GetUintColumn(int column)
 01304        {
 01305            return GetColumn(column, ref allUintColumns);
 01306        }
 1307
 1308        public long[] GetLongColumn(int column)
 01309        {
 01310            return GetColumn(column, ref allLongColumns);
 01311        }
 1312
 1313        public ulong[] GetUlongColumn(int column)
 01314        {
 01315            return GetColumn(column, ref allUlongColumns);
 01316        }
 1317
 1318        public float[] GetFloatColumn(int column)
 01319        {
 01320            return GetColumn(column, ref allFloatColumns);
 01321        }
 1322
 1323        public double[] GetDoubleColumn(int column)
 01324        {
 01325            return GetColumn(column, ref allDoubleColumns);
 01326        }
 1327
 1328        public Vector2[] GetVector2Column(int column)
 01329        {
 01330            return GetColumn(column, ref allVector2Columns);
 01331        }
 1332
 1333        public Vector3[] GetVector3Column(int column)
 01334        {
 01335            return GetColumn(column, ref allVector3Columns);
 01336        }
 1337
 1338        public Vector4[] GetVector4Column(int column)
 01339        {
 01340            return GetColumn(column, ref allVector4Columns);
 01341        }
 1342
 1343        public Vector2Int[] GetVector2IntColumn(int column)
 01344        {
 01345            return GetColumn(column, ref allVector2IntColumns);
 01346        }
 1347
 1348        public Vector3Int[] GetVector3IntColumn(int column)
 01349        {
 01350            return GetColumn(column, ref allVector3IntColumns);
 01351        }
 1352
 1353        public Quaternion[] GetQuaternionColumn(int column)
 01354        {
 01355            return GetColumn(column, ref allQuaternionColumns);
 01356        }
 1357
 1358        public Rect[] GetRectColumn(int column)
 01359        {
 01360            return GetColumn(column, ref allRectColumns);
 01361        }
 1362
 1363        public RectInt[] GetRectIntColumn(int column)
 01364        {
 01365            return GetColumn(column, ref allRectIntColumns);
 01366        }
 1367
 1368        public Color[] GetColorColumn(int column)
 01369        {
 01370            return GetColumn(column, ref allColorColumns);
 01371        }
 1372
 1373        public LayerMask[] GetLayerMaskColumn(int column)
 01374        {
 01375            return GetColumn(column, ref allLayerMaskColumns);
 01376        }
 1377
 1378        public Bounds[] GetBoundsColumn(int column)
 01379        {
 01380            return GetColumn(column, ref allBoundsColumns);
 01381        }
 1382
 1383        public BoundsInt[] GetBoundsIntColumn(int column)
 01384        {
 01385            return GetColumn(column, ref allBoundsIntColumns);
 01386        }
 1387
 1388        public Hash128[] GetHash128Column(int column)
 01389        {
 01390            return GetColumn(column, ref allHash128Columns);
 01391        }
 1392
 1393        public Gradient[] GetGradientColumn(int column)
 01394        {
 01395            return GetColumn(column, ref allGradientColumns);
 01396        }
 1397
 1398        public AnimationCurve[] GetAnimationCurveColumn(int column)
 01399        {
 01400            return GetColumn(column, ref allAnimationCurveColumns);
 01401        }
 1402
 1403        public UnityEngine.Object[] GetObjectColumn(int column)
 01404        {
 01405            return GetColumn(column, ref allObjectRefColumns);
 01406        }
 1407
 1408        // SetOrder
 1409
 1410        public void SetColumnOrder(int columnID, int newSortOrder)
 01411        {
 01412            AssertColumnIDValid(columnID);
 01413            AssertColumnSortOrderValid(newSortOrder);
 01414            int oldSortOrder = columnIDToSortOrderMap[columnID];
 01415            int iterDirection = newSortOrder > oldSortOrder ? 1 : -1;
 01416            for (int i = oldSortOrder; i != newSortOrder; i += iterDirection)
 01417            {
 01418                int columnIDAt = sortedOrderToColumnIDMap[i + iterDirection];
 01419                columnIDToSortOrderMap[columnIDAt] = i;
 01420                sortedOrderToColumnIDMap[i] = sortedOrderToColumnIDMap[i + iterDirection];
 01421            }
 1422
 01423            sortedOrderToColumnIDMap[newSortOrder] = columnID;
 01424            columnIDToSortOrderMap[columnID] = newSortOrder;
 01425        }
 1426
 1427        public void SetAllColumnOrders(int[] sortedColumnIDs)
 01428        {
 01429            AssertSortedColumnsArgValid(sortedColumnIDs);
 01430            for (int i = 0; i < sortedOrderToColumnIDMap.Length; i++)
 01431            {
 01432                int columnID = sortedColumnIDs[i];
 01433                sortedOrderToColumnIDMap[i] = columnID;
 01434                columnIDToSortOrderMap[columnID] = i;
 01435            }
 01436        }
 1437
 1438        public void SetRowOrder(int rowID, int newSortOrder)
 01439        {
 01440            AssertRowIDValid(rowID);
 01441            AssertRowSortOrderValid(newSortOrder);
 1442
 01443            int oldSortOrder = rowIDToDenseIndexMap[rowID];
 01444            int iterDirection = newSortOrder > oldSortOrder ? 1 : -1;
 1445
 01446            for (int i = oldSortOrder; i != newSortOrder; i += iterDirection)
 01447            {
 01448                int rowIDAt = rowDenseIndexToIDMap[i + iterDirection];
 01449                rowIDToDenseIndexMap[rowIDAt] = i;
 01450                rowDenseIndexToIDMap[i] = rowDenseIndexToIDMap[i + iterDirection];
 01451            }
 1452
 01453            SetRowOrderForColumns(allStringColumns, oldSortOrder, newSortOrder);
 01454            SetRowOrderForColumns(allBoolColumns, oldSortOrder, newSortOrder);
 01455            SetRowOrderForColumns(allCharColumns, oldSortOrder, newSortOrder);
 01456            SetRowOrderForColumns(allSbyteColumns, oldSortOrder, newSortOrder);
 01457            SetRowOrderForColumns(allByteColumns, oldSortOrder, newSortOrder);
 01458            SetRowOrderForColumns(allShortColumns, oldSortOrder, newSortOrder);
 01459            SetRowOrderForColumns(allUshortColumns, oldSortOrder, newSortOrder);
 01460            SetRowOrderForColumns(allIntColumns, oldSortOrder, newSortOrder);
 01461            SetRowOrderForColumns(allUintColumns, oldSortOrder, newSortOrder);
 01462            SetRowOrderForColumns(allLongColumns, oldSortOrder, newSortOrder);
 01463            SetRowOrderForColumns(allUlongColumns, oldSortOrder, newSortOrder);
 01464            SetRowOrderForColumns(allFloatColumns, oldSortOrder, newSortOrder);
 01465            SetRowOrderForColumns(allDoubleColumns, oldSortOrder, newSortOrder);
 01466            SetRowOrderForColumns(allVector2Columns, oldSortOrder, newSortOrder);
 01467            SetRowOrderForColumns(allVector3Columns, oldSortOrder, newSortOrder);
 01468            SetRowOrderForColumns(allVector4Columns, oldSortOrder, newSortOrder);
 01469            SetRowOrderForColumns(allVector2IntColumns, oldSortOrder, newSortOrder);
 01470            SetRowOrderForColumns(allVector3IntColumns, oldSortOrder, newSortOrder);
 01471            SetRowOrderForColumns(allQuaternionColumns, oldSortOrder, newSortOrder);
 01472            SetRowOrderForColumns(allRectColumns, oldSortOrder, newSortOrder);
 01473            SetRowOrderForColumns(allRectIntColumns, oldSortOrder, newSortOrder);
 01474            SetRowOrderForColumns(allColorColumns, oldSortOrder, newSortOrder);
 01475            SetRowOrderForColumns(allLayerMaskColumns, oldSortOrder, newSortOrder);
 01476            SetRowOrderForColumns(allBoundsColumns, oldSortOrder, newSortOrder);
 01477            SetRowOrderForColumns(allBoundsIntColumns, oldSortOrder, newSortOrder);
 01478            SetRowOrderForColumns(allHash128Columns, oldSortOrder, newSortOrder);
 01479            SetRowOrderForColumns(allGradientColumns, oldSortOrder, newSortOrder);
 01480            SetRowOrderForColumns(allAnimationCurveColumns, oldSortOrder, newSortOrder);
 01481            SetRowOrderForColumns(allObjectRefColumns, oldSortOrder, newSortOrder);
 01482        }
 1483
 1484        public void SetAllRowOrders(int[] sortedRowIDs)
 01485        {
 01486            AssertSorteRowsArgValid(sortedRowIDs);
 1487
 01488            ReSortRows(allStringColumns, sortedRowIDs);
 01489            ReSortRows(allBoolColumns, sortedRowIDs);
 01490            ReSortRows(allCharColumns, sortedRowIDs);
 01491            ReSortRows(allSbyteColumns, sortedRowIDs);
 01492            ReSortRows(allByteColumns, sortedRowIDs);
 01493            ReSortRows(allShortColumns, sortedRowIDs);
 01494            ReSortRows(allUshortColumns, sortedRowIDs);
 01495            ReSortRows(allIntColumns, sortedRowIDs);
 01496            ReSortRows(allUintColumns, sortedRowIDs);
 01497            ReSortRows(allLongColumns, sortedRowIDs);
 01498            ReSortRows(allUlongColumns, sortedRowIDs);
 01499            ReSortRows(allFloatColumns, sortedRowIDs);
 01500            ReSortRows(allDoubleColumns, sortedRowIDs);
 01501            ReSortRows(allVector2Columns, sortedRowIDs);
 01502            ReSortRows(allVector3Columns, sortedRowIDs);
 01503            ReSortRows(allVector4Columns, sortedRowIDs);
 01504            ReSortRows(allVector2IntColumns, sortedRowIDs);
 01505            ReSortRows(allVector3IntColumns, sortedRowIDs);
 01506            ReSortRows(allQuaternionColumns, sortedRowIDs);
 01507            ReSortRows(allRectColumns, sortedRowIDs);
 01508            ReSortRows(allRectIntColumns, sortedRowIDs);
 01509            ReSortRows(allColorColumns, sortedRowIDs);
 01510            ReSortRows(allLayerMaskColumns, sortedRowIDs);
 01511            ReSortRows(allBoundsColumns, sortedRowIDs);
 01512            ReSortRows(allBoundsIntColumns, sortedRowIDs);
 01513            ReSortRows(allHash128Columns, sortedRowIDs);
 01514            ReSortRows(allGradientColumns, sortedRowIDs);
 01515            ReSortRows(allAnimationCurveColumns, sortedRowIDs);
 01516            ReSortRows(allObjectRefColumns, sortedRowIDs);
 1517
 01518            for (int i = 0; i < sortedRowIDs.Length; i++)
 01519            {
 01520                int rowID = sortedRowIDs[i];
 01521                rowDenseIndexToIDMap[i] = rowID;
 01522                rowIDToDenseIndexMap[rowID] = i;
 01523            }
 01524        }
 1525
 1526        internal void ReSortRows<T>(ArrayHolder<T>[] columns, int[] sortedRowIDs)
 01527        {
 01528            int columnCount = columns?.Length ?? 0;
 01529            for (int i = 0; i < columnCount; i++)
 01530            {
 01531                T[] column = columns[i].TArray;
 01532                T[] newColumn = new T[column.Length];
 01533                for (int j = 0; j < sortedRowIDs.Length; j++)
 01534                {
 01535                    int rowID = sortedRowIDs[j];
 01536                    int oldRowIndex = rowIDToDenseIndexMap[rowID];
 1537
 01538                    newColumn[j] = column[oldRowIndex];
 01539                }
 1540
 01541                columns[i].TArray = newColumn;
 01542            }
 01543        }
 1544
 1545        // Internal
 1546
 1547        internal void AddTypeNameEntryForUnityObjectColumn()
 01548        {
 01549            int nameArrayLength = allObjectRefTypenames?.Length ?? 0;
 01550            Array.Resize(ref allObjectRefTypenames, nameArrayLength + 1);
 01551            allObjectRefTypenames[nameArrayLength] = s_UnityObjectString;
 01552        }
 1553
 1554        internal void RemoveTypeNameEntryForUnityObjectColumn(int columnDenseIndex)
 01555        {
 01556            int nameArrayLength = allObjectRefTypenames?.Length ?? 0;
 01557            allObjectRefTypenames[columnDenseIndex] = allObjectRefTypenames[nameArrayLength];
 01558            Array.Resize(ref allObjectRefTypenames, nameArrayLength - 1);
 01559        }
 1560
 1561        internal void AssertObjectColumnIDValid(int columnID)
 01562        {
 01563            AssertColumnIDValid(columnID);
 01564            if (columnIDToDenseIndexMap[columnID].ColumnType != Serializable.SerializableTypes.Object)
 01565            {
 01566                throw new ArgumentException("Column ID must correspond to a UnityEngine.Object column.");
 1567            }
 01568        }
 1569
 1570        internal int AddColumnInternal<T>(string columnName, ref ArrayHolder<T>[] allColumnsOfType, Serializable.Seriali
 01571        {
 01572            if (insertAtColumnID >= 0)
 01573            {
 01574                AssertColumnIDValid(insertAtColumnID);
 01575            }
 01576            int columnCount = allColumnsOfType?.Length ?? 0;
 01577            Array.Resize(ref allColumnsOfType, columnCount + 1);
 01578            allColumnsOfType[columnCount].TArray = new T[rowCount];
 1579
 01580            int columnID = columnEntriesFreeListHead;
 01581            string[] columnNamesForType = allColumnNames[(int)typeIndex].TArray;
 01582            int columnNamesCount = columnNamesForType?.Length ?? 0;
 01583            Array.Resize(ref columnNamesForType, columnNamesCount + 1);
 01584            columnNamesForType[columnNamesCount] = columnName == null ? columnID.ToString() : columnName;
 01585            allColumnNames[(int)typeIndex].TArray = columnNamesForType;
 1586
 1587
 01588            int columnIDToDenseIndexMapLength = columnIDToDenseIndexMap?.Length ?? 0;
 01589            if (columnID >= columnIDToDenseIndexMapLength)
 01590            {
 01591                int newSize = columnIDToDenseIndexMapLength * 2;
 01592                newSize = newSize == 0 ? 1 : newSize;
 01593                Array.Resize(ref columnIDToDenseIndexMap, newSize);
 01594                for (int i = columnIDToDenseIndexMapLength; i < newSize; i++)
 01595                {
 01596                    ref ColumnEntry entry = ref columnIDToDenseIndexMap[i];
 01597                    entry.columnDenseIndex = i + 1;
 01598                    entry.ColumnType = Serializable.SerializableTypes.Invalid;
 01599                }
 1600
 01601                Array.Resize(ref columnIDToSortOrderMap, newSize);
 01602                for (int i = columnIDToDenseIndexMapLength; i < newSize; i++)
 01603                {
 01604                    columnIDToSortOrderMap[i] = -1;
 01605                }
 01606            }
 1607
 01608            columnEntriesFreeListHead = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 1609
 01610            ref int[] denseIndexToIDMap = ref columnDenseIndexToIDMap[(int)typeIndex].TArray;
 01611            int denseIndexToIDMapLength = denseIndexToIDMap?.Length ?? 0;
 01612            Array.Resize(ref denseIndexToIDMap, denseIndexToIDMapLength + 1);
 01613            denseIndexToIDMap[denseIndexToIDMapLength] = columnID;
 1614
 01615            ref ColumnEntry newEntry = ref columnIDToDenseIndexMap[columnID];
 01616            newEntry.columnDenseIndex = denseIndexToIDMapLength;
 01617            newEntry.ColumnType = typeIndex;
 1618
 01619            int insertAtSortedIndex = insertAtColumnID < 0 ? combinedColumnCount : columnIDToSortOrderMap[insertAtColumn
 01620            Array.Resize(ref sortedOrderToColumnIDMap, combinedColumnCount + 1);
 01621            for (int i = combinedColumnCount; i > insertAtSortedIndex; i--)
 01622            {
 01623                int currentColumnID = sortedOrderToColumnIDMap[i - 1];
 01624                sortedOrderToColumnIDMap[i] = currentColumnID;
 01625                columnIDToSortOrderMap[currentColumnID] = i;
 01626            }
 1627
 01628            if (typeIndex == Serializable.SerializableTypes.Object)
 01629            {
 01630                AddTypeNameEntryForUnityObjectColumn();
 01631            }
 1632
 01633            columnIDToSortOrderMap[columnID] = insertAtSortedIndex;
 01634            sortedOrderToColumnIDMap[insertAtSortedIndex] = columnID;
 1635
 01636            ++combinedColumnCount;
 01637            dataVersion++;
 1638
 01639            return columnID;
 01640        }
 1641
 1642        internal void RemoveColumnInternal<T>(ref ArrayHolder<T>[] allColumnsOfType, Serializable.SerializableTypes type
 01643        {
 01644            AssertColumnIDValid(columnID);
 01645            int columnLocation = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 1646
 01647            int lastIndex = allColumnsOfType.Length - 1;
 01648            allColumnsOfType[columnLocation] = allColumnsOfType[lastIndex];
 01649            Array.Resize(ref allColumnsOfType, lastIndex);
 1650
 01651            ref string[] columnNamesOfType = ref allColumnNames[(int)typeIndex].TArray;
 01652            columnNamesOfType[columnLocation] = columnNamesOfType[lastIndex];
 01653            Array.Resize(ref columnNamesOfType, lastIndex);
 1654
 01655            int columnOrder = columnIDToSortOrderMap[columnID];
 1656
 01657            ref int[] denseIndicesOfType = ref columnDenseIndexToIDMap[(int)typeIndex].TArray;
 01658            int sparseIndexToSwap = denseIndicesOfType[lastIndex];
 1659
 01660            ref ColumnEntry sparseIndexToFree = ref columnIDToDenseIndexMap[columnID];
 01661            sparseIndexToFree.ColumnType = Serializable.SerializableTypes.Invalid;
 01662            sparseIndexToFree.columnDenseIndex = columnEntriesFreeListHead;
 01663            columnEntriesFreeListHead = columnID;
 1664
 01665            columnIDToDenseIndexMap[sparseIndexToSwap].columnDenseIndex = columnLocation;
 01666            denseIndicesOfType[columnLocation] = sparseIndexToSwap;
 01667            Array.Resize(ref denseIndicesOfType, lastIndex);
 1668
 01669            if (typeIndex == Serializable.SerializableTypes.Object)
 01670            {
 01671                RemoveTypeNameEntryForUnityObjectColumn(columnLocation);
 01672            }
 1673
 01674            for (int i = columnOrder + 1; i < combinedColumnCount; i++)
 01675            {
 01676                int currentColumnID = sortedOrderToColumnIDMap[i];
 01677                sortedOrderToColumnIDMap[i - 1] = currentColumnID;
 01678                columnIDToSortOrderMap[currentColumnID] = i - 1;
 01679            }
 1680
 01681            Array.Resize(ref sortedOrderToColumnIDMap, combinedColumnCount - 1);
 1682
 01683            --combinedColumnCount;
 01684            dataVersion++;
 01685        }
 1686
 1687        internal void InsertRowsOfTypeInternal<T>(ref ArrayHolder<T>[] allColumnsOfType, int insertAt, int numberOfNewRo
 01688        {
 01689            int columnCount = allColumnsOfType?.Length ?? 0;
 01690            for (int i = 0; i < columnCount; i++)
 01691            {
 01692                ref T[] rows = ref allColumnsOfType[i].TArray;
 01693                int newRowCount = rowCount + numberOfNewRows;
 01694                Array.Resize(ref rows, newRowCount);
 01695                for (int j = newRowCount - 1; j > insertAt + numberOfNewRows - 1; j--)
 01696                {
 01697                    rows[j] = rows[j - numberOfNewRows];
 01698                }
 1699
 01700                for (int j = 0; j < numberOfNewRows; j++)
 01701                {
 01702                    rows[insertAt + j] = default;
 01703                }
 01704            }
 01705        }
 1706
 1707        internal void DeleteRowsOfTypeInternal<T>(ref ArrayHolder<T>[] allColumnsOfType, int removeAt, int numberOfRowsT
 01708        {
 01709            int columnCount = allColumnsOfType?.Length ?? 0;
 1710
 01711            for (int i = 0; i < columnCount; i++)
 01712            {
 01713                ref T[] rows = ref allColumnsOfType[i].TArray;
 01714                int newRowCount = rowCount - numberOfRowsToDelete;
 1715
 01716                for (int j = removeAt + numberOfRowsToDelete; j < rowCount; j++)
 01717                {
 01718                    rows[j - numberOfRowsToDelete] = rows[j];
 01719                }
 1720
 01721                Array.Resize(ref rows, newRowCount);
 01722            }
 01723        }
 1724
 1725        internal ref T GetCellRef<T>(int rowID, int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 01726        {
 01727            AssertColumnIDValid(columnID);
 01728            AssertRowIDValid(rowID);
 01729            int column = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 01730            int row = rowIDToDenseIndexMap[rowID];
 01731            return ref allColumnsOfType[column][row];
 01732        }
 1733
 1734        internal T GetCell<T>(int rowID, int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 01735        {
 01736            AssertColumnIDValid(columnID);
 01737            AssertRowIDValid(rowID);
 01738            int column = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 01739            int row = rowIDToDenseIndexMap[rowID];
 01740            return allColumnsOfType[column][row];
 01741        }
 1742
 1743        internal ulong SetCell<T>(int rowID, int columnID, ref ArrayHolder<T>[] allColumnsOfType, T value)
 01744        {
 01745            AssertColumnIDValid(columnID);
 01746            AssertRowIDValid(rowID);
 01747            int column = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 01748            int row = rowIDToDenseIndexMap[rowID];
 01749            allColumnsOfType[column][row] = value;
 01750            dataVersion++;
 01751            return dataVersion;
 01752        }
 1753
 1754        internal T[] GetColumn<T>(int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 01755        {
 01756            AssertColumnIDValid(columnID);
 01757            int column = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 01758            return allColumnsOfType[column].TArray;
 01759        }
 1760
 1761        internal void SetRowOrderForColumns<T>(ArrayHolder<T>[] columns, int oldSortOrder, int newSortOrder)
 01762        {
 01763            int columnCount = columns?.Length ?? 0;
 01764            int iterDirection = newSortOrder > oldSortOrder ? 1 : -1;
 01765            for (int i = 0; i < columnCount; i++)
 01766            {
 01767                T[] column = columns[i].TArray;
 1768
 01769                for (int j = oldSortOrder; j != newSortOrder; j += iterDirection)
 01770                {
 01771                    column[j] = column[j + iterDirection];
 01772                }
 01773            }
 01774        }
 1775
 1776        internal void AssertSortedColumnsArgValid(int[] sortedColumnIDs)
 01777        {
 01778            if (sortedColumnIDs == null)
 01779            {
 01780                throw new ArgumentException("sortedColumnIDs array cannot be null.");
 1781            }
 1782
 01783            if (sortedColumnIDs.Length != sortedOrderToColumnIDMap.Length)
 01784            {
 01785                throw new ArgumentException("sortedColumnIDs array must be the same length as GetColumnCount.");
 1786            }
 1787
 01788            for (int i = 0; i < sortedColumnIDs.Length; i++)
 01789            {
 01790                AssertColumnIDValid(sortedColumnIDs[i]);
 01791            }
 01792        }
 1793
 1794        internal void AssertColumnSortOrderValid(int sortedOrder)
 01795        {
 01796            if (sortedOrder >= combinedColumnCount || sortedOrder < 0)
 01797            {
 01798                throw new ArgumentException("Invalid column sort order argument: " + sortedOrder);
 1799            }
 01800        }
 1801
 1802        internal void AssertRowSortOrderValid(int sortedOrder)
 01803        {
 01804            if (sortedOrder >= rowCount || sortedOrder < 0)
 01805            {
 01806                throw new ArgumentException("Invalid row sort order argument: " + sortedOrder);
 1807            }
 01808        }
 1809
 1810        internal void AssertSorteRowsArgValid(int[] sortedRowIDs)
 01811        {
 01812            if (sortedRowIDs == null)
 01813            {
 01814                throw new ArgumentException("sortedRowIDs array cannot be null.");
 1815            }
 1816
 01817            if (sortedRowIDs.Length != rowDenseIndexToIDMap.Length)
 01818            {
 01819                throw new ArgumentException("sortedRowIDs array must be the same length as GetRowCount.");
 1820            }
 1821
 01822            for (int i = 0; i < sortedRowIDs.Length; i++)
 01823            {
 01824                AssertRowIDValid(sortedRowIDs[i]);
 01825            }
 01826        }
 1827    }
 1828}
Generated by: ReportGenerator 5.0.4.0
2023-05-26 - 3:54:11 PM
GitHub | www.palmmedia.de

Coverage by test methods





































































































































































































































































































































































































































































































































































































































































































Methods/Properties

StableTable()
StableTable()
GetDataVersion()
GetColumnCount()
GetRowCount()
GetDisplayName()
SetDisplayName(System.String)
GetFlag(GDX.Tables.ITable/Flags)
SetFlag(GDX.Tables.ITable/Flags, System.Boolean)
GetAllRowDescriptions()
GetRowDescription(System.String)
GetRowDescription(System.Int32)
SetAllRowDescriptionsOrder(GDX.Tables.ITable/RowDescription[])
GetColumnDescription(System.String)
GetColumnDescription(System.Int32)
SetAllColumnDescriptionsOrder(GDX.Tables.ITable/ColumnDescription[])
GetAllColumnDescriptions()
AssertColumnIDValid(System.Int32)
AssertRowIDValid(System.Int32)
SetColumnName(System.String, System.Int32)
GetColumnName(System.Int32)
SetRowName(System.String, System.Int32)
GetRowName(System.Int32)
GetRowNameRef(System.Int32)
GetColumnNameRef(System.Int32)
AddRow(System.String, System.Int32)
AddRows(System.Int32, System.String[], System.Int32)
AddRows(System.Int32, System.Int32[]&, System.String[], System.Int32)
RemoveRow(System.Int32)
AddColumn(GDX.Serializable/SerializableTypes, System.String, System.Int32)
RemoveColumn(GDX.Serializable/SerializableTypes, System.Int32)
SetString(System.Int32, System.Int32, System.String)
SetBool(System.Int32, System.Int32, System.Boolean)
SetChar(System.Int32, System.Int32, System.Char)
SetSByte(System.Int32, System.Int32, System.SByte)
SetByte(System.Int32, System.Int32, System.Byte)
SetShort(System.Int32, System.Int32, System.Int16)
SetUShort(System.Int32, System.Int32, System.UInt16)
SetInt(System.Int32, System.Int32, System.Int32)
SetUInt(System.Int32, System.Int32, System.UInt32)
SetLong(System.Int32, System.Int32, System.Int64)
SetULong(System.Int32, System.Int32, System.UInt64)
SetFloat(System.Int32, System.Int32, System.Single)
SetDouble(System.Int32, System.Int32, System.Double)
SetVector2(System.Int32, System.Int32, UnityEngine.Vector2)
SetVector3(System.Int32, System.Int32, UnityEngine.Vector3)
SetVector4(System.Int32, System.Int32, UnityEngine.Vector4)
SetVector2Int(System.Int32, System.Int32, UnityEngine.Vector2Int)
SetVector3Int(System.Int32, System.Int32, UnityEngine.Vector3Int)
SetQuaternion(System.Int32, System.Int32, UnityEngine.Quaternion)
SetRect(System.Int32, System.Int32, UnityEngine.Rect)
SetRectInt(System.Int32, System.Int32, UnityEngine.RectInt)
SetColor(System.Int32, System.Int32, UnityEngine.Color)
SetLayerMask(System.Int32, System.Int32, UnityEngine.LayerMask)
SetBounds(System.Int32, System.Int32, UnityEngine.Bounds)
SetBoundsInt(System.Int32, System.Int32, UnityEngine.BoundsInt)
SetHash128(System.Int32, System.Int32, UnityEngine.Hash128)
SetGradient(System.Int32, System.Int32, UnityEngine.Gradient)
SetAnimationCurve(System.Int32, System.Int32, UnityEngine.AnimationCurve)
SetObject(System.Int32, System.Int32, UnityEngine.Object)
SetTypeNameForObjectColumn[T](System.Int32)
GetString(System.Int32, System.Int32)
GetBool(System.Int32, System.Int32)
GetChar(System.Int32, System.Int32)
GetSByte(System.Int32, System.Int32)
GetByte(System.Int32, System.Int32)
GetShort(System.Int32, System.Int32)
GetUShort(System.Int32, System.Int32)
GetInt(System.Int32, System.Int32)
GetUInt(System.Int32, System.Int32)
GetLong(System.Int32, System.Int32)
GetULong(System.Int32, System.Int32)
GetFloat(System.Int32, System.Int32)
GetDouble(System.Int32, System.Int32)
GetVector2(System.Int32, System.Int32)
GetVector3(System.Int32, System.Int32)
GetVector4(System.Int32, System.Int32)
GetVector2Int(System.Int32, System.Int32)
GetVector3Int(System.Int32, System.Int32)
GetQuaternion(System.Int32, System.Int32)
GetRect(System.Int32, System.Int32)
GetRectInt(System.Int32, System.Int32)
GetColor(System.Int32, System.Int32)
GetLayerMask(System.Int32, System.Int32)
GetBounds(System.Int32, System.Int32)
GetBoundsInt(System.Int32, System.Int32)
GetHash128(System.Int32, System.Int32)
GetGradient(System.Int32, System.Int32)
GetAnimationCurve(System.Int32, System.Int32)
GetObject(System.Int32, System.Int32)
GetStringRef(System.Int32, System.Int32)
GetBoolRef(System.Int32, System.Int32)
GetCharRef(System.Int32, System.Int32)
GetSbyteRef(System.Int32, System.Int32)
GetByteRef(System.Int32, System.Int32)
GetShortRef(System.Int32, System.Int32)
GetUshortRef(System.Int32, System.Int32)
GetIntRef(System.Int32, System.Int32)
GetUintRef(System.Int32, System.Int32)
GetLongRef(System.Int32, System.Int32)
GetUlongRef(System.Int32, System.Int32)
GetFloatRef(System.Int32, System.Int32)
GetDoubleRef(System.Int32, System.Int32)
GetVector2Ref(System.Int32, System.Int32)
GetVector3Ref(System.Int32, System.Int32)
GetVector4Ref(System.Int32, System.Int32)
GetVector2IntRef(System.Int32, System.Int32)
GetVector3IntRef(System.Int32, System.Int32)
GetQuaternionRef(System.Int32, System.Int32)
GetRectRef(System.Int32, System.Int32)
GetRectIntRef(System.Int32, System.Int32)
GetColorRef(System.Int32, System.Int32)
GetLayerMaskRef(System.Int32, System.Int32)
GetBoundsRef(System.Int32, System.Int32)
GetBoundsIntRef(System.Int32, System.Int32)
GetHash128Ref(System.Int32, System.Int32)
GetGradientRef(System.Int32, System.Int32)
GetAnimationCurveRef(System.Int32, System.Int32)
GetObjectRef(System.Int32, System.Int32)
GetStringColumn(System.Int32)
GetBoolColumn(System.Int32)
GetCharColumn(System.Int32)
GetSbyteColumn(System.Int32)
GetByteColumn(System.Int32)
GetShortColumn(System.Int32)
GetUshortColumn(System.Int32)
GetIntColumn(System.Int32)
GetUintColumn(System.Int32)
GetLongColumn(System.Int32)
GetUlongColumn(System.Int32)
GetFloatColumn(System.Int32)
GetDoubleColumn(System.Int32)
GetVector2Column(System.Int32)
GetVector3Column(System.Int32)
GetVector4Column(System.Int32)
GetVector2IntColumn(System.Int32)
GetVector3IntColumn(System.Int32)
GetQuaternionColumn(System.Int32)
GetRectColumn(System.Int32)
GetRectIntColumn(System.Int32)
GetColorColumn(System.Int32)
GetLayerMaskColumn(System.Int32)
GetBoundsColumn(System.Int32)
GetBoundsIntColumn(System.Int32)
GetHash128Column(System.Int32)
GetGradientColumn(System.Int32)
GetAnimationCurveColumn(System.Int32)
GetObjectColumn(System.Int32)
SetColumnOrder(System.Int32, System.Int32)
SetAllColumnOrders(System.Int32[])
SetRowOrder(System.Int32, System.Int32)
SetAllRowOrders(System.Int32[])
ReSortRows[T](, System.Int32[])
AddTypeNameEntryForUnityObjectColumn()
RemoveTypeNameEntryForUnityObjectColumn(System.Int32)
AssertObjectColumnIDValid(System.Int32)
AddColumnInternal[T](System.String, , GDX.Serializable/SerializableTypes, System.Int32)
RemoveColumnInternal[T](, GDX.Serializable/SerializableTypes, System.Int32)
InsertRowsOfTypeInternal[T](, System.Int32, System.Int32)
DeleteRowsOfTypeInternal[T](, System.Int32, System.Int32)
GetCellRef[T](System.Int32, System.Int32, )
GetCell[T](System.Int32, System.Int32, )
SetCell[T](System.Int32, System.Int32, , T)
GetColumn[T](System.Int32, )
SetRowOrderForColumns[T](, System.Int32, System.Int32)
AssertSortedColumnsArgValid(System.Int32[])
AssertColumnSortOrderValid(System.Int32)
AssertRowSortOrderValid(System.Int32)
AssertSorteRowsArgValid(System.Int32[])